import app from '@/App'

import personSelect from '@/components/asc/PersonSelect'
import download from '@/components/common/download'

import {getNeedDealList,getProcInsTrace,submitWorkListItem,getBpmPscActInfo,
    getNextApprovePerson} from '@/api/api.js'
import { getBackNode,findFileList,getLasApproveInfo,
    getWFConfigActivity} from '@/api/api.js';
import api_home from '@/api/api_home'
import * as Constant from '@/utils/constant'
export default {
    props:['searchParams','order'],
    components:{
        app,
        personSelect,
        download,
    },
    data() {
        return {
            iconDown:true,
            contentidshow:false,
            determinate:'',
            next_actor:'',//当前处理的环节信息
            deal_man:[],
            showDialog:false,
            showCount:0,
            count: 0,
            pageSize:5,
            pageIndex:1,
            hasDealApprove:0, //已处理审批  处理5条自动去刷新页面
            procPicUrl:process.env.PROCPIC_ROOT,
            //模拟数据
            hasData:false,
            data: [],
            busy: false,
            isKaiGuan:false,
            procLog:[],
            fileList:[],
            fileProps:[
                {prop:'fileRealName',label:'文件名'},
                {prop:'createTime',label:'上传时间'},
            ],
            loadDefaultData: true,
            processRouterMap: {
              "SWP-SU\\pur_demIn": {
                "020_队办经理审批": Constant.ROUTE_PUR_PROCESS_DEM_WITHIN_NEXT.index,
                "030_计划协调员审批": Constant.ROUTE_PUR_PROCESS_DEM_WITHIN_NEXT.index,
                "040_调试采购主管审批": Constant.ROUTE_PUR_PROCESS_DEM_WITHIN_NEXT.index
              },
              "SWP-SU\\pur_demOut": {
                "020_队办经理审批": Constant.ROUTE_PUR_PROCESS_DEM_WITHOUT_NEXT.index,
                "030_计划协调员审批": Constant.ROUTE_PUR_PROCESS_DEM_WITHOUT_NEXT.index,
                "040_调试采购主管审批": Constant.ROUTE_PUR_PROCESS_DEM_WITHOUT_NEXT.index
              },
              "SWP-SU\\pur_demChange": {
                "020_队办经理审批": Constant.ROUTE_PUR_PROCESS_DEM_CHANGE_NEXT.index,
                "030_计划协调员审批": Constant.ROUTE_PUR_PROCESS_DEM_CHANGE_NEXT.index,
                "040_调试采购主管审批": Constant.ROUTE_PUR_PROCESS_DEM_CHANGE_NEXT.index
              },
              "SWP-SU\\pur_demClose": {
                "020_计划协调员审批": Constant.ROUTE_PUR_PROCESS_DEM_CLOSE_NEXT.index,
                "030_调试采购主管审批": Constant.ROUTE_PUR_PROCESS_DEM_CLOSE_NEXT.index,
                "040_调试采购主管审批": Constant.ROUTE_PUR_PROCESS_DEM_CLOSE_NEXT.index
              },
              "SWP-SU\\sci_thesis": {
                  "010_提交论文": Constant.ROUTE_SRI_GAIN_THESIS_APPROVE.index,
                  "020_论文管理员审批": Constant.ROUTE_SRI_GAIN_THESIS_APPROVE.index
              },
              "SWP-SU\\sci_budget": {
                  "010_提交预算申请": Constant.ROUTE_SRI_BUDGET_APPROVE.index,
                  "020_预算管理员审批": Constant.ROUTE_SRI_BUDGET_APPROVE.index
              },
              "SWP-SU\\sci_cbpPlan": {
                  "010_提交能力建设年度工作计划": Constant.ROUTE_SRI_GAIN_CBP_PLAN_APPROVE.index,
                  "020_专业分部协调员审批": Constant.ROUTE_SRI_GAIN_CBP_PLAN_APPROVE.index,
                  "030_能力建设管理工程师审批": Constant.ROUTE_SRI_GAIN_CBP_PLAN_APPROVE.index,
                  "040_主任或副主任审批": Constant.ROUTE_SRI_GAIN_CBP_PLAN_APPROVE.index,
              },
              "SWP-SU\\sci_cbpProcess" :{
                  "010_项目负责人提交能建计划进展": Constant.ROUTE_SRI_GAIN_CBP_PROGRESS_APPROVE.index,
                  "020_能力建设管理工程师审批": Constant.ROUTE_SRI_GAIN_CBP_PROGRESS_APPROVE.index,
              },
              "SWP-SU\\sri_alpPlan" :{
                  "010_提交实验室年度工作计划": Constant.ROUTE_SRI_GAIN_ALP_PLAN_APPROVE.index,
                  "020_实验室专家": Constant.ROUTE_SRI_GAIN_ALP_PLAN_APPROVE.index,
                  "030_主任或副主任审批": Constant.ROUTE_SRI_GAIN_ALP_PLAN_APPROVE.index,
              },
              "SWP-SU\\sri_alpProcess" :{
                  "010_项目负责人提交工作进展": Constant.ROUTE_SRI_GAIN_ALP_PROGRESS_APPROVE.index,
                  "020_实验室专家": Constant.ROUTE_SRI_GAIN_ALP_PROGRESS_APPROVE.index,
                  "030_主任或副主任审批": Constant.ROUTE_SRI_GAIN_ALP_PROGRESS_APPROVE.index,
              },
              "SWP-SU\\hr_backApproval":{
                  "010_编制人员调配计划": Constant.ROUTE_HR_BACK_APPROVE.index,
                  "020_队办经理审批": Constant.ROUTE_HR_BACK_APPROVE.index,
                  "030_SAM归档": Constant.ROUTE_HR_BACK_APPROVE.index,
              },
              "SWP-SU\\hr_frontApproval":{
                  "010_编制人员岗位需求": Constant.ROUTE_HR_FONT_APPROVE.index,
                  "020_队办经理审批": Constant.ROUTE_HR_FONT_APPROVE.index,
                  "030_分部经理审批": Constant.ROUTE_HR_FONT_APPROVE.index,
                  "040_专业工程师审批": Constant.ROUTE_HR_FONT_APPROVE.index,
                  "050_专业部门处长审批": Constant.ROUTE_HR_FONT_APPROVE.index,
                  "060_SPB成本审批": Constant.ROUTE_HR_FONT_APPROVE.index,
                  "070_SMB归档": Constant.ROUTE_HR_FONT_APPROVE.index,
              },
          }
        }
    },
    methods: {
        async showNeedDealList(params,loadPageIndex){
            //查询待办列表页面
            let _this = this;
            await getNeedDealList(params).then((result) => {
                if(result.status == "200" && result.data.code == "0"){
                    //数据
                    let data = result.data.data.data;
                    let dataList = data.ToDoTasks;
                    //为dataList 添加一些参数
                    for(let i = 0; i <dataList.length; i++){
                        dataList[i].showProcLogs = [];//流程日志
                        dataList[i].actOptions = [];//下拉框的环节选项 随时切换(同意 退回)
                        dataList[i].nextActOptions = [];//下一环节选项 多个  020 030
                        dataList[i].isEnd = false;//是否为结束节点 默认false 下一环节处理
                        dataList[i].personOptions = [];//当前视图某个环节的审批人选项
                        dataList[i].approvePerson = [];//审批人数组
                        dataList[i].showBack = false;//是否存在退回节点
                        dataList[i].backActInfo = [];//退回节点信息
                        dataList[i].backAct = [];//退回节点
                        dataList[i].backActName = [];//退回节点名称
                        dataList[i].backMan = [];//退回节点的节点处理人ID
                        dataList[i].backManName = [];//退回节点的节点处理人姓名
                        dataList[i].deal_man = [];//当前视图显示的处理人
                        dataList[i].approveSuggest = "同意!";//审批意见
                        dataList[i].determinate = "1";//设置对下一流程默审批通过  1、同意 2、退回
                        dataList[i].sendManId = "s"+dataList[i].procInstID;//设置id 抄送人的标识
                        dataList[i].nexeManId = "n"+dataList[i].procInstID;//设置id 下一处理人的标识 未用到

                        //会签类型 是否重选快速审批人  任务类型  任务处理规则
                        dataList[i].isFastApprove = false;//是否快速审批
                        dataList[i].isReselFastApprove = "";//是否重选快速审批人
                        dataList[i].signType = "";// 1串行会签  其他为非串行会签
                        dataList[i].taskType = "";//1 待办 2 待阅 3 带阅办
                        dataList[i].taskRule = "";//1 只需一人处理 -1 必须所有人处理
                        //日志分页
                        dataList[i].logIndex = 1;
                        dataList[i].logSize = 5;
                        dataList[i].logTotal = 0;

                        if(i == 0){
                            if(_this.pageIndex != 1){
                                dataList[i].iconDown = true;
                                dataList[i].contentidshow = false;
                                dataList[i].showSomeInfo = false; //是否显示 上一审批人和环节等
                            }else{
                                dataList[i].iconDown = false;
                                dataList[i].contentidshow = true;
                                dataList[i].showSomeInfo = true; //是否显示 上一审批人和环节等

                                //默认处理第一条的数据内容 查询流程日志 (里面有判断是否有退回)
                                _this.showProcLogAndLastaMan(dataList[i]);
                                //获取下一步点处理人 有下一环节020 和 相对应的处理人 数组形式
                                _this.getNextDealInfo(dataList[i]);
                                //获取上一处理信息
                                _this.getLasApproveInfoByProcInsId(dataList[i]);

                            }
                        }else{
                            dataList[i].iconDown = true;
                            dataList[i].contentidshow = false;
                            dataList[i].showSomeInfo = false; //是否显示 上一审批人和环节等
                        }
                    }

                    let pageObj = data.Paging;
                    _this.showCount += pageObj.totalCount <= pageObj.pageSize ? pageObj.totalCount:pageObj.pageSize;
                    _this.count = pageObj.totalCount;
                    _this.pageIndex = pageObj.startPage;
                    //后台请求过来的数据要经过调整判断
                    for(let j = 0; j < dataList.length; j++){
                        let repeatData = false;
                        for(let k = 0; k < _this.data.length; k++){
                            if(dataList[j].sn == _this.data[k].sn){
                                repeatData = true;
                                break;
                            }
                        }
                        if(!repeatData){
                            _this.data.push(dataList[j]);
                        }
                    }
                    // _this.data.push(...dataList);
                    _this.hasData = _this.count == 0?false:true;
                    if(loadPageIndex == undefined){
                        //默认展示页面数据 3页
                        if(_this.pageIndex < 3 && _this.pageIndex + 1 <= _this.count){
                            let params = {
                                pageIndex: ++_this.pageIndex ,
                                pageSize: _this.pageSize,
                                type:2,
                            }
                            params = Object.assign(params,this.searchParams,{order:this.order});
                            // _this.showNeedDealList(params);
                        }
                    }else{
                        //提交流程后 应该展现的数据  添加相同的数据到this.data中
                        if(_this.pageIndex < loadPageIndex && _this.pageIndex + 1 <= _this.count){
                            let params = {
                                pageIndex: ++_this.pageIndex ,
                                pageSize: _this.pageSize,
                                type:2,
                            }
                            params = Object.assign(params,this.searchParams,{order:this.order});
                            // _this.showNeedDealList(params);
                        }
                    }
                }
                else{
                    _this.$alert(result.data.msg,_this.$t('cm.tips'));
                }
            }).catch((err) => {

            });
        },
        /**
         * 查询该条待办的流程轨迹
         * @param {待办数据} item
         */
        showProcLogAndLastaMan(item){
            let _this = this;
            let params = {
                procInsId: item.procInstID,
                pageIndex: item.logIndex,
                pageSize: item.logSize,
            };
            getProcInsTrace(params).then((result) => {
                item.showProcLogs = [];
                if(result.status == "200" && result.data.code == "0"){
                    let data = result.data.data.data;
                    //设置页面属性
                    item.logIndex = data.Paging.startPage;
                    item.logSize = data.Paging.pageSize;
                    item.logTotal = data.Paging.totalCount;

                    for(let i = 0; i < data.ProcessTraces.length; i++){
                        item.showProcLogs.push(data.ProcessTraces[i].processLogDTO);
                    }
                    //判断是否有回退信息
                    _this.isBackNode(item);
                }else{
                    _this.$alert(result.data.msg,_this.$t('cm.tips'));
                }
            }).catch((err) => {
                _this.$alert(err,_this.$t('cm.tips'));
            });
        },
        /**
         * 判断是否有回退节点
         * @param {待办数据} item
         */
        isBackNode(item){
            //判断是否有回退按钮
            let procId = item.procID;
            let actId = (item.activityName.split('_'))[0];
            let _this = this;
            //判断是否需要请求http获取数据
            getBackNode(procId,actId).then((result) => {
                console.log("是否存在回退节点：", result);
                if(result.status == "200"){
                    //判断是否有退回节点
                    let arr = result.data.data.data;
                    if(arr.length > 0){
                        //存在多个回退节点的情况
                        for(let i = 0; i < arr.length; i++){
                            let obj = arr[i];
                            item.backAct.push(obj.next_act_metadata);
                            item.backActName.push(obj.next_act_name);
                            _this.getBackNodeInfo(item,obj.next_act_id);
                            _this.getBackMan(obj,item);
                        }
                        item.showBack = true;
                    }else{
                        //说明没有退回节点
                    }
                }
            }).catch((err) => {
                _this.$alert(err,_this.$t('cm.tips'));
            });
        },
        /**
         * 获取退回节点信息 并保存
         */
        getBackNodeInfo:function(item,actId){
            let _this = this;
            getBpmPscActInfo({actId:actId}).then((result) => {
                if(result.status == "200" && result.data.code == "0"){
                    let data = result.data.data.data;
                    item.backActInfo.push(data);
                }else{
                    _this.$alert(result.data.msg,_this.$t('cm.tips'));
                }
            }).catch((err) => {
                _this.$alert(err,_this.$t('cm.tips'));
            });
        },
        /**
         * 获取退回环节当时的处理人 通过日志来找到。
         * @param {*} obj
         * @param {*} item
         */
        getBackMan:function(obj,item){
            //obj 为回退的环节
            item.showProcLogs.filter(o=>{
                if(o.actName.indexOf(obj.next_act_metadata) > -1){
                    item.backMan.push(o.approverAccount);
                    item.backManName.push(o.approverChsName);
                }
            });
        },
        /**
         * 获取下一环节和下一处理人开始
         * @param {待办数据 } item
         */
        getNextDealInfo:function(item){
            let _this = this;
            let params = {
                actId: item.activityID,
                procId: item.procID,
                procInstId: item.procInstID,
                node: (item.activityName.split('_'))[0],
            }
            //通过下一步点处理人获取相关信息(得到下一环节以及环节的处理人
            //这里的环节和处理人信息需要获取更详细的信息)
            getNextApprovePerson(params).then((result) => {
                if(result.status == "200" && result.data.code == "0"){
                    let data = result.data.data.data;
                    for(let actMetadata in data){
                       //处理下一环节以及下一步处理人
                       this.getNextActAndDealer(actMetadata,data,item);
                    }
                }else{
                    _this.$alert(result.data.msg,_this.$t('cm.tips'));
                }
            }).catch((err) => {
                _this.$alert(err,_this.$t('cm.tips'));
            });
        },
        //处理下一环节以及下一步处理人
        //actMetadata (020、030这样的数据)
        //dealer (020 、030 环节的处理人 --作为下一步处理人)
        //item (流程的其他信息 --查询待办)
        getNextActAndDealer:function(actMetadata,dealer,item){
            //遍历节点信息 获得节点id(actId)
            let _this = this;
            let params = {
                fullName: item.processFullName,
                procSetId: this.$store.state.proc.procSetId
            };
            getWFConfigActivity(params).then((result) => {
                if(result.status == "200" && result.data.code == "0"){
                    //存在多个下一环节的情况
                    let d = result.data.data.data;
                    for(let i = 0; i < d.length; i++){
                        if(d[i].actMetaData == actMetadata){
                            //获取节点详细信息(020) 保存到item中
                            _this.getNodeDetails(d[i],actMetadata,dealer,item);
                        }
                        if(actMetadata == "END"){
                            item.isEnd = true
                        }
                    }
                }else{
                    _this.$alert(result.data.msg,_this.$t('cm.tips'));
                }
            }).catch((err) => {
                _this.$alert(err,_this.$t('cm.tips'));
            });
        },
        /**
         * 获取节点信息,通过节点id 设置视图上的下一环节和下一步处理人
         * @param {节点id} act
         * @param {020、030} actMetadata
         * @param {下一步点处理人信息} dealer
         * @param {待办信息} item
         */
        getNodeDetails:function(act,actMetadata,dealer,item){
            let _this = this;
            getBpmPscActInfo({actId:act.actID}).then((result) => {
                if(result.status == "200" && result.data.code == "0"){
                    let data = result.data.data.data;
                    item.actOptions.push(data);//设置当前下拉框的环节选项
                    item.nextActOptions.push(data);//下一环节选项(审批通过的)
                    if(item.next_actor == undefined){
                        item.next_actor = data.actMetadata;//默认选择一个为下一环节
                    }
                    let dealerArr = dealer[actMetadata];
                    _this.unifyUser(dealerArr,item);//设置下一步处理人
                    item.isReselFastApprove = data.isReselFastDealer == 1?true:false;//设置是否重选快速审批
                    item.isFastApprove = data.isFastDeal == 1 ? true:false;//设置是否快速审批
                }else{
                    _this.$alert(result.data.msg,_this.$t('cm.tips'));
                }
            }).catch((err) => {
                _this.$alert(err,_this.$t('cm.tips'));
            });
        },
        /**
         * 统一用户格式
         * @param {下一处理人} users
         * @param {待办信息} item
         */
        unifyUser:function(users,item){
            for(let i = 0; i < users.length; i++){
                if(typeof(users[i].item_principal_desc) != "undefined" && typeof(users[i].item_principal_desc) != null){
                    item.personOptions.push("["+users[i].item_principal+"]"+users[i].item_principal_desc);//当前视图人员选项
                    item.approvePerson.push("["+users[i].item_principal+"]"+users[i].item_principal_desc);//下一环节人员选项(审批通过)
                }
            }
            // item.nextPersonOptions.push(item.approvePerson);
        },
        /**
         * 获取上一处理人信息
         * @param {待办数据} item
         */
        getLasApproveInfoByProcInsId:function(item){
            let _this = this;
            getLasApproveInfo({procInsId:item.procInstID}).then((result) => {
                if(result.status == "200" && result.data.code == "0"){
                    let data = result.data.data;
                    //设置上一审批意见
                    let comment = data.comment;
                    item.lastApproveSuggest = comment == ""?"暂无":comment;
                    item.lastApproveMan = data.approveChsName;
                    item.lastApproveTime = data.endDateTime;
                    item.lastSN = data.SN;
                }else{
                    _this.$alert(result.data.msg,_this.$t('cm.tips'));
                }
            }).catch((err) => {
                _this.$alert(err,_this.$t('cm.tips'));
            });
        },
        /**
         * 跳转详情或点击标签显示数据
         * @param {待办内容} item
         * @param {是否跳转详情} gotoUrl
         */
        loadData:function(item,gotoUrl){
            //查询流程日志
            this.showProcLogAndLastaMan(item);
            //获取下一步点处理人 有下一环节020 和 相对应的处理人 数组形式
            this.getNextDealInfo(item);
            //获取上一处理信息
            this.getLasApproveInfoByProcInsId(item);
            let _this = this;
            if(gotoUrl){
                setTimeout(function(){
                    _this.$router.push({path:"/need_deal_task_details/"+item.procInstID,query:{obj:item}});
                },1000);

            }else{
                item.showSomeInfo = true; //是否显示 上一审批人和环节等
                item.iconDown = !item.iconDown;
                item.contentidshow = !item.contentidshow;
            }
        },
        /**
         * 视图列表右侧的图标，点击显示待办详细数据
         * @param {*} item
         */
        showDetails:function(item){
            if(!item.showSomeInfo){
                this.loadData(item,false);
            }else{
                item.iconDown = !item.iconDown;
                item.contentidshow = !item.contentidshow;
            }
        },
        /**
         * 跳转查看详情  或者加载待办信息
         * @param {*} row
         */
        gotoDetails:function(item){
            console.log("异常调试信息=485===need_deal_list.js===："+item.showSomeInfo,item)
            this.isKaiGuan = false;
            if(!item.showSomeInfo){
                this.loadData(item,true);
            }else{
                // 此处出现404异常，真实情况应该是需要按照当前所提交的流程展示对应的路由
                // this.$router.push({path:"/need_deal_task_details/"+row.procInstID,query:{obj:row}});

                let _this = this;
                if(this.processRouterMap[item.processFullName][item.activityName]) {
                  api_home.updateVisitTime({processFullName: item.processFullName, processName: item.processName}, response => {
                  })
                    setTimeout(()=>{
                        _this.$router.push({path:this.processRouterMap[item.processFullName][item.activityName],query:{obj:item}});
                    }, 2000)
                }else{
                    _this.$alert("please check processRouterMap.");
                }
            }

        },
        /**
         * 点击跳转日志页面 去查看流程日志
         * @param {*} row
         */
        gotoLogs:function(row){
            this.isKaiGuan = false;
            this.$router.push({path:'/log',query:{obj:row}});
        },
        /**
         * 查询业务文件 通过getFileList 查询出数据到对话框中显示
         * @param {*} row
         */
        gotoFiles:function(row){
            this.getFileList(row.procGuid,row.formInstID);
        },
        /**
         * 视图上的审批意见显示在文本域中
         * @param {} e
         * @param {*} item
         */
        selectText:function(e,item){
            //文本内容
            let text = e.currentTarget.innerHTML;
            item.approveSuggest = text;
        },
        /**
         * 视图上 提交按钮
         * 点击通过当前节点的是否快速审批参数判断进入详情还是直接提交
         * @param {*} item
         */
        commitProc(item){
            //当不支持快速审批时，会触发打开详情界面
            if(item.isFastApprove == null || item.isFastApprove == false){
                this.gotoDetails(item);
            }else{
                this.approveFlow(item);
            }
        },
        /**
         * 提交流程
         * @param {待办参数}} item
         */
        approveFlow:function(item){
            //先验证是否填写相应的数据
            //下一步处理人　不包含在退回
            if(item.determinate != "2" && !item.isEnd){
                if(document.getElementById(item.nexeManId)!= null && document.getElementById(item.nexeManId).value != ""){
                    item.deal_man = document.getElementById(item.nexeManId).value.split(',');
                }else{
                    //不能重选快速审批人
                }
            }
            //下一步抄送人
            let copygiveMans = document.getElementById(item.sendManId).value;
            let copygive = []; //形式 ['[pxmwrya]阮洋','[pxmwzyp]张膺鹏']
            if(copygiveMans !=""){
                copygive = copygiveMans.split(',');
            }
            let params = {
                staffNoBefore: item.preActivitySender,//上一审批人
                actId: item.activityID,
                procId: this.$store.state.proc.procId,
                procChName:this.$store.state.proc.procName,//流程中文名
                task_type:'',//任务类型
                mergeTask:'0',//合并任务
                slotCount:'1',//任务处理规则
                resign:'',//会签类型
                reselMan:'',//是否重选快速审批人
                act_name:item.activityName, //当前节点名称
                now_deal_act:(item.activityName.split('_'))[0],//当前节点
                deal_answer:item.determinate,//同意 还是退回
                next_deal_act:item.next_actor,//下一节点
                next_deal_name:item.deal_man,//下一处理人名称
                deal_suggest:item.approveSuggest,//审批意见
                copygive:copygive,//抄送人
                approveMan:'',//当前提交人  后台可以取到
                // procGuid:item.procGuid,
                procGuid:item.formInstID,
                procInstId:item.procInstID,
                sn:item.SN,
                isEnd:item.isEnd,
                backAct:item.showBack == true? item.backAct[0]:null,//我这个流程没有多个退回节点。
                backMan:item.showBack == true? item.backMan[0]:null,
                backManName:item.showBack == true? item.backManName[0]:null,
            }
            //设置任务类型、会签规则、会签类型、是否重选快速审批人 http://cudflow-d
            let selNextAct = item.actOptions.find(n =>{
                return (n.actMetadata == item.next_actor);
            })
            if(item.determinate != "2"){
                params.task_type = selNextAct.taskActType;
                params.mergeTask = selNextAct.isMergeTask;
                params.slotCount = selNextAct.taskProcessRule;
                params.resign = selNextAct.reSignType;
                params.reselMan = selNextAct.isReselFastDealer;
            }else{
                //如果为退回节点  也要设置
                let backNodeInfo = item.backActInfo.find(obj => {
                    return obj.actMetadata == item.next_actor
                })
                params.task_type = backNodeInfo.taskActType;
                params.mergeTask = backNodeInfo.isMergeTask;
                params.slotCount = backNodeInfo.taskProcessRule;
                params.resign = backNodeInfo.reSignType;
                params.reselMan = backNodeInfo.isReselFastDealer;
            }
            //处理结论、下一环节、下一步处理人
            if(item.determinate == ""){
                this.$alert(this.$t('ndt.selDealSuggest'),this.$t('cm.tips'));
                return ;
            }else if(item.next_actor == ""){
                this.$alert(this.$t('ndt.selNextAct'),this.$t('cm.tips'));
                return ;
            }else if(item.isEnd == false && item.deal_man.length == 0){
                this.$alert(this.$t('ndt.selNextDealer'),this.$t('cm.tips'));
                return ;
            }
            let _this = this;
            this.$confirm(_this.$t('ndt.isApproved'),_this.$t('cm.tips'),{
                confirmButtonText: _this.$t('te.confirm'),
                cancelButtonText: _this.$t('te.cancel'),
                cancelButtonClass: 'btn-second',
                confirmButtonClass: 'btn-default',
            }).then(function(){

                let array = _this.data;
                submitWorkListItem(params).then((result) => {
                    if(result.status == "200" && result.data.code =="0"){
                        _this.data.splice(array.findIndex(array => array.procInstID == item.procInstID),1);
                        //进行刷新页面操作
                        let flushParam = {
                            pageIndex : 1,
                            pageSize : _this.pageSize,
                            type:2,
                        }
                        //提交流程后 第一个数据自动展开
                        if(_this.data.length > 0){
                            //展开一条流程
                            _this.data[0].iconDown = false;
                            _this.data[0].contentidshow = true;
                            _this.data[0].showSomeInfo = true; //是否显示 上一审批人和环节等
                            //默认处理第一条的数据内容 查询流程日志 (里面有判断是否有退回)
                            _this.showProcLogAndLastaMan(_this.data[0]);
                            //获取下一步点处理人 有下一环节020 和 相对应的处理人 数组形式
                            _this.getNextDealInfo(_this.data[0]);
                            //获取上一处理信息
                            _this.getLasApproveInfoByProcInsId(_this.data[0]);
                        }
                        flushParam = Object.assign(flushParam,_this.searchParams,{order:_this.order});
                        _this.showNeedDealList(flushParam,_this.pageIndex);
                    }else{
                        _this.$alert(result.data.msg,_this.$t('cm.tips'));
                    }

                }).catch((err) => {

                });
            })
        },
        /**
         * 监听滚动条事件
         */
        menu:function(){
            if(this.isKaiGuan){
                //myScrollbar  在App.vue页面  滚动条
                let let1 = this.$root.$children[0].$refs['myScrollbar'].wrap.scrollTop;
                let let2 = this.$root.$children[0].$refs['myScrollbar'].wrap.scrollHeight;
                let let3 = document.body.scrollHeight;
                let _this = this;
                if((parseInt(let1 + let3) == parseInt(let2 + 17)) && this.showCount < this.count  ){
                    //模拟加载数据
                    this.isKaiGuan = false;
                    let loadingInstance = this.$loading({target:'#load',text:_this.$t('cm.loading')});
                    let params = {
                        pageIndex: ++this.pageIndex,
                        pageSize: this.pageSize,
                        type:2,
                        t:Math.random()
                    }
                    params = Object.assign(params,this.searchParams,{order:this.order});
                    this.showNeedDealList(params);
                    loadingInstance.close();
                    this.isKaiGuan = true;
                }
            }
        },
        /**
         * 日期转化方法
         * @param {} row
         * @param {*} col
         * @param {*} value
         */
        transDate:function(row,col,value){
            var time = new Date(value);
            var y = time.getFullYear();
            var m = time.getMonth()+1;
            var d = time.getDate();
            var h = time.getHours();
            var mm = time.getMinutes();
            var s = time.getSeconds();
            if(y == "0001"){
                return ;
            }
            return y+'-'+this.add0(m)+'-'+this.add0(d)+' '+this.add0(h)+':'+this.add0(mm)+':'+this.add0(s)
        },
        /**
         * 切换审批意见为退回，重新选择下一环节和下一审批人
         * @param {*} item
         */
        triggerBack:function(item){
            //切换下一环节和下一处理人
            //:label="i.actName" :key="i.actMetaData" :value="i.actMetaData"
            item.actOptions = [];
            for(let i = 0; i < item.backAct.length; i++){
                let option = {actName:item.backActName[i],actMetadata:item.backAct[i]};
                item.actOptions.push(option);
            }
            item.next_actor = item.actOptions[0].actMetadata;
            item.showBackMan= item.backManName[0] + "["+item.backMan[0]+"]";
            item.approveSuggest = "退回!";
            //设置快速审批
            let backNode = item.backActInfo.find(obj => {
                return obj.actMetadata == item.next_actor;
            });
            item.isFastApprove = backNode.isFastDeal == 1 ? true:false;
            // this.$forceUpdate();
        },
        /**
         * 切换审批意见为同意，重新选择下一环节和下一审批人
         * @param {*} item
         */
        triggerAgree:function(item){
            //切换下一环节和下一审批人
            item.actOptions = item.nextActOptions;
            item.next_actor = item.actOptions[0].actMetadata;
            item.approveSuggest = "同意!";
            item.isFastApprove = item.actOptions[0].isFastDeal == 1 ? true:false;
            this.$forceUpdate();
        },
        /**
         * 切换环节时调用的方法
         * @param {*} val
         * @param {*} item
         */
        changeAct:function(val,item){
            //判断是否
            if(!item.showBack){//非回退
                let index = 0;
                item.nextActOptions.some(o => {
                  if(o.actMetadata != val){
                    ++index;
                  }
                  return (o.actMetadata == val);
                });
                //设置审批人
                item.personOptions = item.nextPersonOptions[index];
                //设置是否快速审批
                item.isFastApprove = item.nextActOptions[index].isReselFastDealer == "1"?true:false;
            }else{//回退
                let index = 0;
                item.backAct.some(o => {
                    if(o != val){
                        ++index;
                    }
                    return (o == val);
                });
                //设置审批人
                item.showBackMan= "["+item.backMan[index]+"]"+item.backManName[index];
                this.$forceUpdate();
            }
        },
        /**
         * 日期格式调整
         * @param {*} m
         */
        add0:function(m){
            return m<10?'0'+m:m
        },
        /**
         * 查询文件列表，显示在对话框中
         * @param {*} guid
         * @param {*} formNo
         */
        getFileList:function(guid,formNo){
            let _this = this;
            _this.fileList = [];
            //formNo=1 为原来的旧数据 不考虑了 formNo 为业务id
            findFileList({winId:formNo}).then((result) => {
                if(result.status == "200" && result.data.code =="0"){
                    _this.fileList = result.data.data;
                    _this.showDialog = true;
                    // _this.$router.push({path:'/download',query:{fileLists:_this.fileList,fileProps:_this.fileProps}})
                }else{
                    _this.$alert(result.data.msg,_this.$t('cm.tips'));
                }
            }).catch((err) => {
                _this.$alert(err,_this.$t('cm.tips'));
            });

        },
        /**
         * 新增浏览器窗口 展现流程图
         * @param {*} row
         */
        showProcPic:function(row){
            window.open(this.procPicUrl+row.procInstID);
        },
        /**
         * 关闭弹出框(文件列表))
         */
        closeDialog:function(){
            this.showDialog = false;
        },
        //日志翻页操作
        changeLogPage:function(index,item){
            item.logIndex = index;
            this.showProcLogAndLastaMan(item);
        },
        //日志翻页操作
        prePage:function(index,item){
            item.logIndex = index;
            this.showProcLogAndLastaMan(item);
        },
        //日志翻页操作
        nextPage:function(index,item){
            item.logIndex = index;
            this.showProcLogAndLastaMan(item);
        },
        editProcInst:function(item){
          console.log("异常调试信息====835=====："+item)
          item.showProcLogs = [];//流程日志
          item.actOptions = [];
          item.nextActOptions = [];//下一环节选项
          item.isEnd = false;//是否为结束节点 默认false 下一环节处理
          item.personOptions = [];//某个环节的审批人
          item.approvePerson = [];//审批人数组
          //查询流程日志
          this.showProcLogAndLastaMan(item);
          //获取下一步点处理人 有下一环节020 和 相对应的处理人 数组形式
          this.getNextDealInfo(item);
          let _this = this;
          if(this.processRouterMap[item.processFullName][item.activityName]) {
              api_home.updateVisitTime({processFullName: item.processFullName, processName: item.processName}, response => {
              })
              setTimeout(()=>{
                _this.$router.push({path:this.processRouterMap[item.processFullName][item.activityName],query:{obj:item}});
              }, 2000)
          }else{
              _this.$alert("please check processRouterMap.");
          }

          // setTimeout(function(){
          //     _this.$router.push({path:"/need_deal_task_details/"+item.procInstID,query:{obj:item}});
          // },1000);

      },
    },
    mounted() {
        //绝对不能根据滚动条的高度来进行调整
        //自动显示15条数据 每5条提交后自动刷新页面 还是判断没有滚动条自动刷新页面   给  count 和 showCount 赋值  模拟点击提交
        //成功后删除该条数据，但要保证始终有滚动条，如果监听是否有滚动条来决定是否有数据
        //当然 count和showCount要进行判断
        //首次加载3次，然后每次加载5个，后台也要处理 加载15个的原因在上面  这块不要了
        let params = {
            pageIndex: this.pageIndex,
            pageSize: this.pageSize,
            type:2,
            t:Math.random()
        }

        this.showNeedDealList(params);

        //判断滚动条位置，自动滑到最顶部
        // this.$root.$children[0].$refs['myScrollbar'].wrap.scrollTop = 0;
        this.isKaiGuan = true;
        window.addEventListener('scroll',this.menu,true);
    },
    destroyed() {
        //  删除监听事件
        window.removeEventListener('scroll',this.menu,true);
    },
    computed: {
        changeCollapse:function(){
            //用于对话框的对齐
            return this.$root.COLLAPSE;
          },
    },
    watch: {
        searchParams:function(){
            //监听 进行条件查询
            this.pageIndex = 1;
            let params = {
                pageIndex: 1,
                pageSize: this.pageSize,
            };
            params = Object.assign(params,this.searchParams,{order:this.order});
            //去掉原来的数据
            this.data = [];
            this.showCount = 0;
            this.showNeedDealList(params);
            //判断滚动条位置，自动滑到最顶部
            // this.$root.$children[0].$refs['myScrollbar'].wrap.scrollTop = 0;
            this.isKaiGuan = true;
        },
        order:function(){
            //1 降序 2升序
            this.pageIndex = 1;
            let params = {
                pageIndex: 1,
                pageSize: this.pageSize,
            };
            params = Object.assign(params,this.searchParams,{order:this.order});
            //去掉原来的数据
            this.data = [];
            this.showCount = 0;
            this.showNeedDealList(params);
            //判断滚动条位置，自动滑到最顶部
            // this.$root.$children[0].$refs['myScrollbar'].wrap.scrollTop = 0;
            this.isKaiGuan = true;

        }
    },
}
